package com.yuncheng.spcyApi.selectXzxkApi.service;

import cn.hutool.core.collection.CollectionUtil;
import com.yuncheng.spcyApi.constant.common.BusinessConstant;
import com.yuncheng.spcyApi.flow.*;
import com.yuncheng.spcyApi.utils.GetUuIdUtils;
import com.yuncheng.spcyApi.utils.StringPatternUtils;
import com.yuncheng.spcyApi.vo.hbjc.BhbSqsxJbxxVo;
import com.yuncheng.vo.CurrentUserVo;
import org.apache.commons.collections.CollectionUtils;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.yuncheng.spcyApi.busService.InitWjjlService;
import com.yuncheng.spcyApi.selectXzxkApi.api.XzspJkApi;
import com.yuncheng.spcyApi.busService.BusService;
import com.yuncheng.spcyApi.busService.FlowJobBlsxService;
import com.yuncheng.spcyApi.constant.common.LogConstant;
import com.yuncheng.spcyApi.constant.common.SpcyConstant;
import com.yuncheng.spcyApi.constant.sys.SysConfigConstant;
import com.yuncheng.spcyApi.entity.SpcySqsxBasic;
import com.yuncheng.spcyApi.entity.SpcySqsxBczgjl;
import com.yuncheng.spcyApi.entity.SpcySqsxBqbzjl;
import com.yuncheng.spcyApi.entity.SpcySqsxJob;
import com.yuncheng.exception.BusinessException;
import com.yuncheng.spcyApi.selectXzxkApi.constant.PutZwxtConstant;
import com.yuncheng.spcyApi.selectXzxkApi.vo.*;
import com.yuncheng.spcyApi.service.*;
import com.yuncheng.spcyApi.spcyService.SqsxQywjclService;
import com.yuncheng.spcyApi.utils.GetCurrentUserUtils;

import com.yuncheng.spcyApi.vo.common.Result;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Lazy;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import utils.DateConversionUtils;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Optional;


/**
 * 政务系统 - 对接接口 - 业务
 */
@Component(value = "putZwxtService")
public class PutZwxtService {

    private static final Logger log = LoggerFactory.getLogger(PutZwxtService.class);

    @Resource
    @Lazy
    private SpcyFlowService spcyFlowService;

    @Resource
    private SpcyQyFlowService spcyQyFlowService;

    @Resource
    @Lazy
    private FlowNodeService flowNodeService;

    @Resource
    @Lazy
    private BusService busService;

    @Resource
    @Lazy
    private ISpcySqsxBaiscService spcySqsxBaiscService;

    @Resource
    private ISpcySqsxBqbzjlService spcySqsxBqbzjlService;

    @Resource
    private ISpcySqsxBczgjlService spcySqsxBczgjlService;

    @Resource
    private XzspJkApi xzspJkApi;

    @Resource
    @Lazy
    private ISpcyLogService spcyLogService;

    @Resource
    @Lazy
    private FlowJobBlsxService flowJobBlsxService;

    @Resource
    private ISysConfigService sysConfigService;

    @Resource
    private SqsxQywjclService sqsxQywjclService;

    @Resource
    private InitWjjlService initWjjlService;

    @Resource
    private XzspXzxkService xzspXzxkService;

    /**
     * 是否开启同步政务服务系统-补充材料同步
     */
    private boolean verifyEnableSyncZwfwxtClFile(){
        String code = Optional.ofNullable(sysConfigService.getSysConfigByCode(SysConfigConstant.SYNC_ZWFWXT_BCZGCL)).orElseGet(()->"0");
        if (code.equals("0")){
            return false;
        }else {
            return true;
        }
    }

    /**
     * 是否开启同步政务服务系统-整改材料同步
     */
    private boolean verifyEnableSyncZwfwxtZgClFile(){
        String code = Optional.ofNullable(sysConfigService.getSysConfigByCode(SysConfigConstant.SYNC_ZWFWXT_ZGCL)).orElseGet(()->"0");
        if (code.equals("0")){
            return false;
        }else {
            return true;
        }
    }

    /**
     * 是否开启同步政务服务系统-企业撤件申请材料同步
     */
    private boolean verifyEnableSyncZwfwxtQycjsqClFile(){
        String code = Optional.ofNullable(sysConfigService.getSysConfigByCode(SysConfigConstant.SYNC_ZWFWXT_QYCJSQCL)).orElseGet(()->"0");
        if (code.equals("0")){
            return false;
        }else {
            return true;
        }
    }

    /** 是否开启同步政务服务事项 */
    private boolean verifyEnableSyncSqsx(){
        String code = Optional.ofNullable(sysConfigService.getSysConfigByCode(SysConfigConstant.SYNC_ZWFWXT_SQSX)).orElseGet(()->"0");
        if (code.equals("0")){
            return false;
        }else {
            return true;
        }
    }

    /**
     * 是否开启同步政务服务系统实时推送流转记录接口：1开启，0不开启
     */
    private boolean verifyEnableSyncZwfwxtSstslzjl(){
        String code = Optional.ofNullable(sysConfigService.getSysConfigByCode(SysConfigConstant.SYNC_ZWFWXT_SSTSLZJL)).orElseGet(()->"0");
        if (code.equals("0")){
            return false;
        }else {
            return true;
        }
    }

    /**
     * 验证token-令牌校验
     * @return
     */
    public String verifyTokenInfo(String sessionToken){
        String tokenInfo = xzspJkApi.getTokenInfo(sessionToken);

        return tokenInfo;
    }

    /***********************************************[     退回政务服务  接口  ]*******************************************************/

    /**
     * 如果事项不属于审评中心办理，应进行退回，审评中心应对事项进行终止，
     * 终止类型是“非中心办理事项”；如果事项属于中心办理但不属于本科室办理，
     * 进行内部转办；如果事项属于科室则进行内部流转办理。
     */

    /**
     * 退回政务服务接口  (超创)  (1)
     * 用于审评中心退回发错的待办事项给政务服务中心
     * @param sqsxid 申请事项id
     * @param thyy 退回意见
     */
    public boolean returnZwfwxt(String sqsxid,String thyy){
        CurrentUserVo currentUser = GetCurrentUserUtils.getCurrentUser();
        if (currentUser == null){
            throw new BusinessException("登录已失效，请重新登录！");
        }
        String username = currentUser.getLoginName();
        String thblr = currentUser.getName(); // 退回办理人
        String thsj = DateConversionUtils.DateToDays(new Date()); // 退回时间

        if (StringUtils.isBlank(sqsxid)){
            throw new BusinessException("申请事项参数为空！");
        }

        SpcySqsxBasic sqsx = spcySqsxBaiscService.selectSqsxInfoById(sqsxid);
        if (sqsx == null){
            throw new BusinessException("当前申请事项不存在！");
        }

        if (StringUtils.isBlank(sqsx.getFxzspzt()) || !sqsx.getFxzspzt().equals(SpcyConstant.SQSX_BASIC_XZSPZT_YES)){
//            throw new BusinessException("当前申请事项["+sqsx.getFsxmc()+"不属于政务服务系统数据，提交失败！");
            log.error("当前申请事项[{}]不属于政务服务系统数据，提交失败！", sqsx.getFsxmc());

            return true;
        }

        String sxsqjbxxid = sqsx.getFsxsqjbxxid();

        boolean isEnableSync = verifyEnableSyncSqsx(); // 是否开启同步
        boolean flag = false;
        if (isEnableSync) {
            flag = xzspJkApi.returnZwfwxt(sxsqjbxxid, thyy, thblr, thsj, username, null);
        }else {
            flag = true;
        }
        if (flag) {
            spcySqsxBaiscService.updateSqsxThzwfw(sqsxid);

//            ypscFlowService.endSpcyFlowJob(sqsxid,"该事项不属于审评中心办理，退回到政务服务系统。");

            String log = "退回政务服务接口: ";
            log += "事项名称：[" + sqsx.getFsxmc() + "]; \n";
            log += "申请单编号：[" + sqsx.getFsqdbh() + "]; ";
            spcyLogService.addLogs(LogConstant.LOGS_SQSX_BASIC + "-" + PutZwxtConstant.SQSX_LCZT_FZXBLSX, log, sqsxid, SpcyConstant.LOGS_SYS_TYPE_TJ, SpcyConstant.LOGS_SYS_TYPE_TJ);
        }

        return flag;
    }


    /***********************************************[     推送办理意见  接口  ]*******************************************************/

    /**
     * 事项办理完毕以后在移送确认环节，调用政务服务系统的选择办理人接口选择好办理人，
     * 先调用政务服务的推送现场检查任务审查结论信息接口，推送结论。
     * 在调调用政务服务的推送现场检查材料接口，推送现场检查材料。
     * 在调调用政务服务的推送内部流转办理意见。
     */

    /**
     * 推送审评流转办理意见接口  (超创)  (2)
     * 用于审评中心推送内部流转办理意见给政务服务
     */
    public void pushSpJobLzjl(String sqsxid){
        if (StringUtils.isBlank(sqsxid)){
            log.error("申请事项参数为空！");
        }

        SpcySqsxBasic sqsx = spcySqsxBaiscService.selectSqsxInfoById(sqsxid);
        if (sqsx == null){
            log.error("当前申请事项不存在！");
            return;
        }

        if (StringUtils.isBlank(sqsx.getFxzspzt()) || !sqsx.getFxzspzt().equals(SpcyConstant.SQSX_BASIC_XZSPZT_YES)){
            log.error("当前申请事项["+sqsx.getFsxmc()+"不属于政务服务系统数据，操作失败！");
            return;
        }

        String sxsqjbxxid = sqsx.getFsxsqjbxxid();

        // 流转记录
        List<SpcySqsxJob> jobList = busService.getWtsJobListBySqsxId(sqsxid);

        if (CollectionUtil.isEmpty(jobList)){
            log.info("没有未推送的流转意见记录！");
            return;
        }

        // 生成推送的流转记录
        List<XzspJkApiTslzyjVo> tslzyjVoList = new ArrayList<>();


            for (SpcySqsxJob job : jobList){
                XzspJkApiTslzyjVo tslzyjVo = new XzspJkApiTslzyjVo();
                tslzyjVo.setSxsqjbxx_id(sxsqjbxxid);
                tslzyjVo.setHjmc(job.getFhjmc());
                tslzyjVo.setBlfs(Optional.ofNullable(job.getFbllx()).orElseGet(()->SpcyConstant.BLLX_BL));

                if (job.getFblsj() != null) {
                    tslzyjVo.setBljsrq(DateConversionUtils.DateToDays(job.getFblsj()));
                }else if (job.getFfssj() != null){
                    tslzyjVo.setBljsrq(DateConversionUtils.DateToDays(job.getFfssj()));
                }else {
                    tslzyjVo.setBljsrq(DateConversionUtils.DateToDays(job.getCreateTime()));
                }

                tslzyjVo.setBlr(job.getFblr());
                if (StringUtils.isBlank(tslzyjVo.getBlr()) && StringUtils.isNotBlank(job.getFdbr())){
                    tslzyjVo.setBlr(StringPatternUtils.getStringsByIds(job.getFdbr())[0]);
                }else if (StringUtils.isBlank(job.getFdbr())){
                    tslzyjVo.setBlr("管理员");
                }

                tslzyjVo.setBlbm(job.getFblbm());
                if (StringUtils.isBlank(tslzyjVo.getBlbm())){
                    tslzyjVo.setBlbm(BusinessConstant.Dw_NAME);
                }

                if (StringUtils.isBlank(job.getFblyj())){
                    tslzyjVo.setBlyj("同意");
                }else {
                    tslzyjVo.setBlyj(job.getFblyj());
                }

                tslzyjVo.setBlsygr(Optional.ofNullable(job.getFsyts()).orElseGet(()->"0"));
                tslzyjVoList.add(tslzyjVo);
            }


        boolean flag = xzspJkApi.pushSpJobLzjl(tslzyjVoList, null);
        if (flag){
            busService.updateWtsJobList(sqsxid); // 批量更新已推送数据
        }

    }

    /**
     * 推送审评流转办理意见接口  (超创)  (2)-单例实时推送
     * 用于审评中心推送内部流转办理意见给政务服务
     */
    @Async(value = "asyncNormalTask")
    public void pushSingletonSpJobLzjl(String sqsxid){
        // 是否开启实时推送意见
        if (!verifyEnableSyncZwfwxtSstslzjl()){
            return;
        }

        if (StringUtils.isBlank(sqsxid)){
            log.error("推送审评流转办理意见接口单例实时推送-申请事项参数为空！");
        }

        SpcySqsxBasic sqsx = spcySqsxBaiscService.selectCodeFxzspztAndById(sqsxid);
        if (sqsx == null){
            log.error("当前申请事项不存在！");
            return;
        }

        if (StringUtils.isBlank(sqsx.getFxzspzt()) || !sqsx.getFxzspzt().equals(SpcyConstant.SQSX_BASIC_XZSPZT_YES)){
            log.error("当前申请事项["+sqsx.getFsxmc()+"不属于政务服务系统数据，操作失败！");
            return;
        }

        String sxsqjbxxid = sqsx.getFsxsqjbxxid();

        // 流转记录
        List<SpcySqsxJob> jobList = busService.getWtsJobListBySqsxId(sqsxid);

        if (CollectionUtil.isEmpty(jobList)){
            log.info("没有未推送的流转意见记录！");
            return;
        }

        // 生成推送的流转记录
        List<XzspJkApiTslzyjVo> tslzyjVoList = new ArrayList<>();

        for (SpcySqsxJob job : jobList){
            XzspJkApiTslzyjVo tslzyjVo = new XzspJkApiTslzyjVo();
            tslzyjVo.setSxsqjbxx_id(sxsqjbxxid);
            tslzyjVo.setHjmc(job.getFhjmc());
            tslzyjVo.setBlfs(Optional.ofNullable(job.getFbllx()).orElseGet(()->SpcyConstant.BLLX_BL));

            if (job.getFblsj() != null) {
                tslzyjVo.setBljsrq(DateConversionUtils.DateToDays(job.getFblsj()));
            }else if (job.getFfssj() != null){
                tslzyjVo.setBljsrq(DateConversionUtils.DateToDays(job.getFfssj()));
            }else {
                tslzyjVo.setBljsrq(DateConversionUtils.DateToDays(job.getCreateTime()));
            }

            tslzyjVo.setBlr(job.getFblr());
            if (StringUtils.isBlank(tslzyjVo.getBlr()) && StringUtils.isNotBlank(job.getFdbr())){
                tslzyjVo.setBlr(StringPatternUtils.getStringsByIds(job.getFdbr())[0]);
            }else if (StringUtils.isBlank(job.getFdbr())){
                tslzyjVo.setBlr("管理员");
            }

            tslzyjVo.setBlbm(job.getFblbm());
            if (StringUtils.isBlank(tslzyjVo.getBlbm())){
                tslzyjVo.setBlbm(BusinessConstant.Dw_NAME);
            }

            if (StringUtils.isBlank(job.getFblyj())){
                tslzyjVo.setBlyj("同意");
            }else {
                tslzyjVo.setBlyj(job.getFblyj());
            }

            tslzyjVo.setBlsygr(Optional.ofNullable(job.getFsyts()).orElseGet(()->"0"));
            tslzyjVoList.add(tslzyjVo);
        }

        boolean flag = xzspJkApi.pushSpJobLzjl(tslzyjVoList, null);
        if (flag){
            busService.updateWtsJobList(jobList); // 批量更新已推送数据
        }

    }

    /***********************************************[     补齐补正 接口  ]*******************************************************/

    /**
     * 审评中心审查申请材料发现需要对企业提出补充信息及材料申请，可以先走内部审批流程审核补齐补正意见，
     * 或者直接填写补齐补正意见，调用政务服务发起补充信息及材料接口向企业发出补齐补正申请。
     * 企业提交补齐补正材料以后，政务服务系统调用审评系统的接受补齐补正结果接口，
     * 审评中心系统向事项经办人发送短信告知企业已提交补齐补正，并在系统的补齐补正栏显示已提交的补齐补正材料。
     */

    /**
     * 推送企业补齐补正通知接口 - 补充信息及材料 (超创)  (6)
     * 用于审评中心向政务服务企业端发起补齐补正
     * @param bqbzyj 补齐补正数据
     */
    public void pushQyBqbzNotice(PutBqbzVo bqbzyj){
        CurrentUserVo currentUser = GetCurrentUserUtils.getCurrentUser();
        if (currentUser == null){
            throw new BusinessException("登录已失效，请重新登录！");
        }

        if (StringUtils.isBlank(bqbzyj.getFsqsxid())){
            throw new BusinessException("申请事项参数为空！");
        }

        if (StringUtils.isBlank(bqbzyj.getFbqbzyj())){
            throw new BusinessException("补齐补正意见为空！");
        }

        SpcySqsxBasic sqsx = spcySqsxBaiscService.selectSqsxInfoById(bqbzyj.getFsqsxid());
        if (sqsx == null){
            throw new BusinessException("当前申请事项不存在！");
        }

        bqbzyj.setFfqr(currentUser.getName());
        bqbzyj.setFfqrq(new Date());
        if (StringUtils.isBlank(bqbzyj.getFsffsdx())){
            bqbzyj.setFsffsdx("否");
        }

        if (StringUtils.isNotBlank(bqbzyj.getFdxnr())){
            bqbzyj.setFsffsdx("是");
        }

        if (StringUtils.isNotBlank(bqbzyj.getFbqbzsx())){
            Date jzrq = flowJobBlsxService.getJzrqBygzrJRq(bqbzyj.getFfqrq(), bqbzyj.getFbqbzsx());
            bqbzyj.setFjzrq(jzrq);
        }

        /*List<SpcySqsxBqbzjl> zgjlList = spcySqsxBqbzjlService.list(new LambdaQueryWrapper<SpcySqsxBqbzjl>()
                .eq(SpcySqsxBqbzjl::getFsqsxid, bqbzyj.getFsqsxid())
                .eq(SpcySqsxBqbzjl::getFwczt, "否"));
        if (CollectionUtils.isNotEmpty(zgjlList)){
            throw new BusinessException("当前申请事项["+sqsx.getFsxmc()+"已经发起了补正，待补正完后再次发起！");
        }*/

        if (StringUtils.isBlank(sqsx.getFxzspzt()) || !sqsx.getFxzspzt().equals(SpcyConstant.SQSX_BASIC_XZSPZT_YES)){

            throw new BusinessException("当前申请事项["+sqsx.getFsxmc()+"不属于政务服务系统数据，提交失败！");
        }

        String sxsqjbxxid = sqsx.getFsxsqjbxxid();

        boolean isEnableSync = verifyEnableSyncSqsx(); // 是否开启同步
        boolean flag = false;
        if (isEnableSync) {
            // 推送企业补充信息及材料通知接口
            flag = xzspJkApi.pushQyBqbzNotice(sxsqjbxxid, bqbzyj, null, null, null);

            bqbzyj.setFwczt("否");
        }else {
            flag = true;

            bqbzyj.setFwczt("是");
        }
        if (flag) {

            /*spcySqsxBqbzjlService.save(bqbzyj);

            spcySqsxBaiscService.updateSqsxPushQyBqbzNotice(bqbzyj.getFsqsxid(), bqbzyj.getFfqrq());

            Result result = spcyQyFlowService.addBqbzJob(sqsx, bqbzyj.getFsqsxid(), bqbzyj.getJobid(), bqbzyj.getFbqbzyj());
            if (!result.isSuccess()){
                log.error("推送企业补齐补正通知接口-创建补齐补正流程失败：{}", result.getMessage());
            }else {
                sqsxQywjclService.syncWjmlScyjToBcscyj(sqsx.getId());
                initWjjlService.updateZzzBqbzFileByTbwdz(sqsx.getId());
            }*/
        }

    }

    /**
     * 生成补齐补正历史
     * @param bqbzyj
     * @return
     */
    public boolean pushQyBqbzNoticeNew(PutBqbzVo bqbzyj){
        boolean resultFlag = false;

        if (StringUtils.isBlank(bqbzyj.getFsqsxid())){
            log.error("申请事项参数为空！");
            return resultFlag;
        }

        CurrentUserVo currentUser = GetCurrentUserUtils.getCurrentUser();
        if (currentUser == null){
            log.error("登录已失效，请重新登录！");
            return resultFlag;
        }

        SpcySqsxBasic sqsx = spcySqsxBaiscService.selectSqsxInfoById(bqbzyj.getFsqsxid());
        if (sqsx == null){
            log.error("当前申请事项不存在！");
            return resultFlag;
        }

        bqbzyj.setFfqr(currentUser.getName());
        bqbzyj.setFfqrq(new Date());

        if (StringUtils.isBlank(bqbzyj.getFsffsdx())){
            bqbzyj.setFsffsdx("否");
        }

        if (StringUtils.isNotBlank(bqbzyj.getFdxnr())){
            bqbzyj.setFsffsdx("是");
        }

        try {
            if (StringUtils.isNotBlank(bqbzyj.getFbqbzsx())){
                Date jzrq = flowJobBlsxService.getJzrqBygzrJRq(bqbzyj.getFfqrq(), bqbzyj.getFbqbzsx());
                bqbzyj.setFjzrq(jzrq);
            }
        }catch (Exception e){

        }

        /** 删除已经存在记录 */
        SpcySqsxBqbzjl zgjlList = this.getNowBqbznr(bqbzyj.getFsqsxid());
        if (zgjlList != null){
            spcySqsxBqbzjlService.removeById(zgjlList.getId());

            spcySqsxBaiscService.updateSqsxPushQyBqbzNoticeQx(bqbzyj.getFsqsxid());
        }

        /*if (StringUtils.isBlank(sqsx.getFxzspzt()) || !sqsx.getFxzspzt().equals(SpcyConstant.SQSX_BASIC_XZSPZT_YES)){
            log.error("当前申请事项[{}]不属于政务服务系统数据，提交失败！", sqsx.getFsxmc());
            return resultFlag;
        }*/

        bqbzyj.setId(GetUuIdUtils.ReplaceUuId());
        bqbzyj.setFwczt("否");
        bqbzyj.setFfqr(GetCurrentUserUtils.getCurrentUserName());
        bqbzyj.setFfqrq(new Date());
        spcySqsxBqbzjlService.save(bqbzyj);

        spcySqsxBaiscService.updateSqsxPushQyBqbzNotice(bqbzyj.getFsqsxid(), bqbzyj.getFfqrq());

        return true;
    }

    /**
     * 补齐补正审核，完成修改
     * @param sqsxid
     * @param jobid
     * @param currentJob
     */
    public void pushQyBqbzNoticeWc(String sqsxid, String jobid, SpcySqsxJob currentJob){

        SpcySqsxBqbzjl bqbzyj = this.getNowBqbznr(sqsxid);
        if (bqbzyj == null){
            return;
        }

        SpcySqsxBasic sqsx = spcySqsxBaiscService.selectSqsxYwxxById(sqsxid);
        if (sqsx == null){
            return;
        }

        String sxsqjbxxid = Optional.ofNullable(sqsx.getFsxsqjbxxid()).orElseGet(()->"");

        boolean isEnableSync = verifyEnableSyncSqsx(); // 是否开启同步
        boolean flag = false;
        if (isEnableSync) {

            /** 属于行政审批数据 */
            if (StringUtils.isNotBlank(sqsx.getFxzspzt()) && sqsx.getFxzspzt().equals(SpcyConstant.SQSX_BASIC_XZSPZT_YES)) {
                // 推送企业补充信息及材料通知接口
                try {
                    flag = xzspJkApi.pushQyBqbzNotice(sxsqjbxxid, bqbzyj, null, null, null);
                } catch (Exception e) {
                    log.error("提交政务接口失败：" + e.getMessage());
                }
            }

            /*SpcySqsxJob clscJob = spcyFlowService.getNowNodeSpcyJob(sqsxid, false, SpcyFlowConstant.HJMC_CLSC, false);
            flowNodeService.copyNewJob(SpcyConstant.BLZT_DB, sqsxid,
                    "", "",
                    "", "",
                    clscJob, GetCurrentUserUtils.getCurrentUser(),
                    "", "");*/
        }else {

            /*LambdaUpdateWrapper<SpcySqsxBqbzjl> updateWrapper = new LambdaUpdateWrapper<>();
            updateWrapper.eq(SpcySqsxBqbzjl::getFsqsxid, sqsxid);
            updateWrapper.eq(SpcySqsxBqbzjl::getFwczt, "否");

            SpcySqsxBqbzjl updateBean = new SpcySqsxBqbzjl();
            updateBean.setFwczt("是");
            updateBean.setFwcrq(new Date());
            spcySqsxBqbzjlService.update(updateBean, updateWrapper);*/

            /** 创建环节 */
            SpcySqsxJob clscJob = spcyFlowService.getNowNodeSpcyJob(sqsxid, false, SpcyFlowConstant.HJMC_CLSC, false);
            flowNodeService.copyNewJob(SpcyConstant.BLZT_DB, sqsxid,
                    "", "",
                    "", "",
                    clscJob, GetCurrentUserUtils.getCurrentUser(),
                    "", "");
        }

        // 新增企业补正待办
        try {
            Result result = spcyQyFlowService.addBqbzJob(null, sqsxid, jobid, currentJob, bqbzyj.getFbqbzyj());
            if (!result.isSuccess()) {
                log.error("推送企业补齐补正通知接口-创建补齐补正流程失败：{}", result.getMessage());
            }
        }catch (Exception e){
            log.error("推送企业补齐补正通知接口-创建补齐补正流程异常：{}", e);
        }


        /** 同步文件目录审查意见-补充意见 */
        sqsxQywjclService.syncWjmlScyjToBcscyj(sqsxid);

        /** 补正文件完成 */
        initWjjlService.updateZzzBqbzFileByTbwdz(sqsxid);

        /** 补正通知文件盖章 */
        initWjjlService.verifyAutoGzBqbzFile(sqsxid);

        /** 给企业发生短信-补齐补正 */
//        SpcySqsxBasic sqsx = spcySqsxBaiscService.selectSqsxYwxxById(sqsxid);
        xzspXzxkService.bqbzSendSmsToQyLxr(bqbzyj, sqsx);
    }

    /**
     * 获取当前补齐补正的内容
     */
    public SpcySqsxBqbzjl getNowBqbznr(String sqsxid){
        List<SpcySqsxBqbzjl> zgjlList = spcySqsxBqbzjlService.list(new LambdaQueryWrapper<SpcySqsxBqbzjl>()
                .eq(SpcySqsxBqbzjl::getFsqsxid, sqsxid)
                .eq(SpcySqsxBqbzjl::getFwczt, "否")
                .orderByDesc(SpcySqsxBqbzjl::getFfqrq));
        if (CollectionUtil.isNotEmpty(zgjlList)){
            return zgjlList.get(0);
        }

        return null;
    }

    /** 验证是否存在发起未完成的整改记录
     * @return true: 存在
     * */
    public boolean verifySfExistsZgjlWithWwc(String sqsxid){
        if (spcySqsxBczgjlService.selectCountByFwczt(sqsxid, "否") > 0){
            return true;
        }

        return false;
    }

    /**
     * 更新补齐补正短信内容
     */
    public void updateBqbz(SpcySqsxBqbzjl bean){
        LambdaUpdateWrapper<SpcySqsxBqbzjl> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.eq(SpcySqsxBqbzjl::getId, bean.getId());

        SpcySqsxBqbzjl updateBean = new SpcySqsxBqbzjl();
        updateBean.setFdxnr(bean.getFdxnr());
        spcySqsxBqbzjlService.update(updateBean, updateWrapper);
    }

    /**
     * 接受企业提交补齐补正结果接口 (中心) (7)
     * 器械科、化妆品、药品注册：为实现一次性补正要求，建议加多一个审评中心确认环节，待审评中心确认以后再算一次补正。
     * 药品生产、流通科：都行
     */
    public void jsQyTjbqbzJg(XzspJkApiJszgjgParamVo jszgjgVo){
        /*String access_token = jszgjgVo.getAccess_token();
        if (StringUtils.isBlank(access_token)){
            throw new BusinessException("access_token不能为空！");
        }*/
        XzspJkApiJszgjgVo param = jszgjgVo.getParam();

        if (StringUtils.isBlank(param.getSxsqjbxx_id())){
            throw new BusinessException("操作失败，事项申请基本信息参数为空！");
        }

        if (StringUtils.isBlank(param.getTjsj())){
            throw new BusinessException("操作失败，提交时间为空！");
        }

        List<SpcySqsxBasic> sqsxList = spcySqsxBaiscService.list(new LambdaQueryWrapper<SpcySqsxBasic>()
                .eq(SpcySqsxBasic::getFsxsqjbxxid, param.getSxsqjbxx_id()));
        if (CollectionUtils.isEmpty(sqsxList)){
            throw new BusinessException("操作失败，没有相匹配的申请事项数据！");
        }

        String sqsxid = sqsxList.get(0).getId();
        SpcySqsxBasic sqsx = sqsxList.get(0);

        /** 补齐补正记录 */
        List<SpcySqsxBqbzjl> bqbzjlList = spcySqsxBqbzjlService.list(new LambdaQueryWrapper<SpcySqsxBqbzjl>()
                .eq(SpcySqsxBqbzjl::getFsqsxid, sqsxid)
                .eq(SpcySqsxBqbzjl::getFwczt, "否"));

        if (CollectionUtils.isEmpty(bqbzjlList)){
            log.error("不存在相关补齐补正信息！数据id{}",sqsxid);
            return;
        }

        /** 完成补齐补正相关 */
        spcyQyFlowService.zwBqbzwcCreateClscDb(sqsxid, sqsx);

        /** 同步政务系统-补充材料 */
        try {
            if (verifyEnableSyncZwfwxtClFile()) {
                sqsxQywjclService.syncZwxtBqbzclToLocalWjcl(sqsxid, param.getSxsqjbxx_id());
            }
        }catch (Exception e){
            log.error("同步政务系统-补充材料错误：", e.getMessage());
        }

    }

    public void jsQyTjbqbzJgTest(XzspJkApiJszgjgParamVo jszgjgVo){
        XzspJkApiJszgjgVo param = jszgjgVo.getParam();

        if (StringUtils.isBlank(param.getSxsqjbxx_id())){
            throw new BusinessException("操作失败，事项申请基本信息id为空！");
        }

        List<SpcySqsxBasic> sqsxList = spcySqsxBaiscService.list(new LambdaQueryWrapper<SpcySqsxBasic>()
                .eq(SpcySqsxBasic::getFsxsqjbxxid, param.getSxsqjbxx_id()));
        if (CollectionUtils.isEmpty(sqsxList)){
            throw new BusinessException("操作失败，没有相匹配的申请事项数据！");
        }

        String sqsxid = sqsxList.get(0).getId();

        // 补齐补正记录
        List<SpcySqsxBqbzjl> bqbzjlList = spcySqsxBqbzjlService.list(new LambdaQueryWrapper<SpcySqsxBqbzjl>()
                .eq(SpcySqsxBqbzjl::getFsqsxid, sqsxid)
                .eq(SpcySqsxBqbzjl::getFwczt, "否")
                .orderByDesc(SpcySqsxBqbzjl::getFfqrq));

        if (CollectionUtils.isEmpty(bqbzjlList)){
            log.error("不存在相关补齐补正信息！数据id{}",sqsxid);
            throw new BusinessException("不存在相关补齐补正信息！");
        }

        // 更新补齐补正完成状态
        SpcySqsxBqbzjl bqbzjl = bqbzjlList.get(0);
        String fqrq = "";
        if (bqbzjl.getFfqrq() != null){
            fqrq = DateConversionUtils.DateToYMDHMSChineseString(bqbzjl.getFfqrq());
        }
        bqbzjl.setFwczt("是");
        bqbzjl.setFwcrq(new Date());
        spcySqsxBqbzjlService.updateById(bqbzjl);

        // 申请事项 - 发送短信
        SpcySqsxBasic sqsx = spcySqsxBaiscService.getById(sqsxid);
        if (sqsx != null) {
            sqsx.setFbqbzwcrq(bqbzjl.getFwcrq());
            sqsx.setFzwxtbzzt(PutZwxtConstant.SQSX_BQBZZT_YBZ);
            spcySqsxBaiscService.updateById(sqsx);
        }

        StringBuffer smsContent = new StringBuffer("");
        if (StringUtils.isNotBlank(sqsx.getFsqdbh())){
            smsContent.append("申请单号[").append(sqsx.getFsqdbh()).append("]");
        }

        if (StringUtils.isNotBlank(sqsx.getFsxmc())){
            smsContent.append("申请事项[").append(sqsx.getFsxmc()).append("]");
        }
        smsContent.append("在 ").append(fqrq).append(" 发起的补齐补正已经完成了。");

        // 审评查验流程-当前待办环节
        SpcySqsxJob nowNodeSpcyJob = spcyFlowService.getNowNodeSpcyJob(sqsxid,false, SpcyFlowConstant.HJMC_CLSC, false);
        if (nowNodeSpcyJob != null) {
            spcyFlowService.bjBqbzJob(sqsx, sqsxid, nowNodeSpcyJob, "补齐补正完成。");

            busService.sendNextNodeSmsContent(nowNodeSpcyJob, smsContent.toString());
        }

    }

    /***********************************************[     整改 接口  ]*******************************************************/

    /**
     *  现场检查完成以后发现企业有需要整改的地方，参照补齐补正的做法；
     * 调用政务服务推送整改要求接口向企业发出整改申请，企业提交整改材料以后政务服务系统调用审评系统接受整改结果接口，
     * 告知审评系统已完成整改。审评系统向经办人发送信息，在整改材料栏显示企业提交的整改材料。
     * 这里要注意审评系统，应设置有整改材料栏，可以由审评中心进行上传，在最后移送材料的时候一起移送
     */

    /**
     * 推送企业补充整改通知接口  (超创)  (8)
     * 药品生产、流通、注册、化妆品：
     * 可以要求企业进行整改，可以传要求整改的函和意见。也可以科室自己传，移送的时候要对应到企业整改材料。
     */
    @Async(value = "asyncNormalTask")
    public Result pushQyZgNotice(FlowVo flowVo, String sqsxid){
        if (StringUtils.isBlank(flowVo.getSffqzg()) || !flowVo.getSffqzg().equals("是")){
            return Result.ok();
        }

        SpcySqsxBczgjl bczgjl = new SpcySqsxBczgjl();
        bczgjl.setFsqsxid(sqsxid);
        bczgjl.setFzgsx(flowVo.getFzgsx());
        bczgjl.setFyjsx(flowVo.getFyjsx());
        bczgjl.setFzgyj(flowVo.getFzgyj());
        bczgjl.setFsffsdx(flowVo.getFsffsdx());
        bczgjl.setFdxnr(flowVo.getFdxnr());

        this.pushQyZgNotice(bczgjl);

        return Result.ok();
    }

    public Result pushQyZgNotice(SpcySqsxBczgjl bczgjl){

        if (StringUtils.isBlank(bczgjl.getFsqsxid())){
            return Result.error("事项参数为空！");
        }

        /*List<SpcySqsxBczgjl> zgjlList = spcySqsxBczgjlService.list(new LambdaQueryWrapper<SpcySqsxBczgjl>()
                .eq(SpcySqsxBczgjl::getFsqsxid, bczgjl.getFsqsxid())
                .eq(SpcySqsxBczgjl::getFwczt, "否"));
        if (CollectionUtils.isNotEmpty(zgjlList)){
            return Result.error("当前事项已经发起了整改,待整改完后再次发起！");
        }*/

        String sxsqjbxxid = "";
        SpcySqsxBasic sqsx = spcySqsxBaiscService.selectSqsxYwxxById(bczgjl.getFsqsxid());
        if (sqsx == null){
            return Result.error("当前申请事项不存在！");
        }
        if (sqsx.getFhbsxzt() == 1){
            List<BhbSqsxJbxxVo> bhbSqsxJbxxVos = spcySqsxBaiscService.selectBhbsqsxListByFhbsxid(sqsx.getId());
            if (CollectionUtil.isNotEmpty(bhbSqsxJbxxVos)){
                sxsqjbxxid = bhbSqsxJbxxVos.get(0).getFsxsqjbxxid();
            }else {
                sxsqjbxxid = sqsx.getFsxsqjbxxid();
            }
        }else {
            sxsqjbxxid = sqsx.getFsxsqjbxxid();
        }

        /*if (StringUtils.isBlank(sqsx.getFxzspzt()) || !sqsx.getFxzspzt().equals(SpcyConstant.SQSX_BASIC_XZSPZT_YES)){

            return Result.error("当前申请事项["+sqsx.getFsxmc()+"不属于政务服务系统数据，提交失败！");
        }*/

        if (StringUtils.isBlank(bczgjl.getFzgyj())){
            return Result.error("整改意见为空！");
        }

        bczgjl.setFfqr(GetCurrentUserUtils.getCurrentUserName());
        bczgjl.setFfqrq(new Date());
        if (StringUtils.isBlank(bczgjl.getFsffsdx())){
            bczgjl.setFsffsdx("否");
        }
        if (StringUtils.isNotBlank(bczgjl.getFdxnr())){
            if (StringUtils.isBlank(bczgjl.getFsffsdx())) {
                bczgjl.setFsffsdx("是");
            }
        }else {
            bczgjl.setFsffsdx("否");
        }

        try {
            if (StringUtils.isNotBlank(bczgjl.getFzgsx())){
                Date jzrq = flowJobBlsxService.getJzrqBygzrJRq(bczgjl.getFfqrq(), bczgjl.getFzgsx());
                bczgjl.setFjzrq(jzrq);
            }
        }catch (Exception e){
            log.error("推送企业补充整改通知接口：计算截止日期错误：{}", e.getMessage());
        }

        bczgjl.setId(GetUuIdUtils.ReplaceUuId());
        spcySqsxBczgjlService.save(bczgjl);
        spcySqsxBaiscService.updateSqsxPushQyBcZgNotice(sqsx.getId());



        boolean isEnableSync = verifyEnableSyncSqsx(); // 是否开启同步
        boolean flag = false;
        if (isEnableSync) {

            /** 属于行政审批数据 */
            if (StringUtils.isNotBlank(sqsx.getFxzspzt()) && sqsx.getFxzspzt().equals(SpcyConstant.SQSX_BASIC_XZSPZT_YES)) {
                // 推送企业整改通知接口
                flag = xzspJkApi.pushQyBcZgNotice(sxsqjbxxid, bczgjl, null, null, null);
            }else {
                flag = true;
            }

            bczgjl.setFwczt("否");
        }else {
            flag = true;

            bczgjl.setFwczt("否");
        }

        if (flag) {
//            spcySqsxBczgjlService.save(bczgjl);

            /** 新增企业整改待办 */
//            spcyQyFlowService.addQyZgclJob(null, sqsx.getId(), sqsx.getFqyid(), sqsx.getFqymc(), bczgjl.getFzgyj());

//            spcySqsxBaiscService.updateSqsxPushQyBcZgNotice(sqsx.getId());

            /** 整改通知书文件完成-240704新增 */
//            initWjjlService.updateZgtzsFileByTbwdz(sqsx.getId());

            /** 整改通知书文件盖章-240704新增 */
//            initWjjlService.verifyAutoGzZgtzsFile(sqsx.getId());

            /** 给企业发生短信-整改通知-240704新增 */
//            xzspXzxkService.zgtzSendSmsToQyLxr(bczgjl, sqsx);
        }

        return Result.ok();
    }

    /**
     *  接受企业提交补充整改结果接口 (中心) (9)
     *  需要能接收到整改完成的短信即可
     */
    public void jsQytjbczgJg(XzspJkApiJszgjgParamVo jszgjgVo){
        /*String access_token = jszgjgVo.getAccess_token();
        if (StringUtils.isBlank(access_token)){
            throw new BusinessException("access_token不能为空！");
        }*/
        XzspJkApiJszgjgVo param = jszgjgVo.getParam();

        if (StringUtils.isBlank(param.getSxsqjbxx_id())){
            throw new BusinessException("操作失败，事项申请基本信息参数为空！");
        }

        if (StringUtils.isBlank(param.getTjsj())){
            throw new BusinessException("操作失败，提交时间为空！");
        }

        /** 查询事项信息 */
        List<SpcySqsxBasic> sqsxList = spcySqsxBaiscService.list(new LambdaQueryWrapper<SpcySqsxBasic>()
                .eq(SpcySqsxBasic::getFsxsqjbxxid, param.getSxsqjbxx_id()));
        if (CollectionUtils.isEmpty(sqsxList)){
            throw new BusinessException("操作失败，没有相匹配的申请事项数据！");
        }
        String sqsxid = sqsxList.get(0).getId();
        SpcySqsxBasic sqsx = sqsxList.get(0);

        /** 整改记录 */
        /*List<SpcySqsxBczgjl> zgList = spcySqsxBczgjlService.list(new LambdaQueryWrapper<SpcySqsxBczgjl>()
                .eq(SpcySqsxBczgjl::getFsqsxid, sqsxid)
                .eq(SpcySqsxBczgjl::getFwczt, "否")
                .orderByDesc(SpcySqsxBczgjl::getFfqrq));

        if (CollectionUtils.isEmpty(zgList)){
            log.error("不存在相关整改信息！数据id {}", sqsxid);
            return;
        }*/

        /** 整改完成通知 */
        spcyQyFlowService.zwZgwcCreateNotice(sqsxid, sqsx);

        /** 同步政务服务系统-整改材料 */
        try {
            if (verifyEnableSyncZwfwxtZgClFile()) {
                sqsxQywjclService.syncZwxtZgclToLocalWjcl(sqsxid,param.getSxsqjbxx_id());
            }
        }catch (Exception e){
            log.error("同步政务服务系统-整改材料错误：", e.getMessage());
        }
    }

    /**
     * 获取当前整改通知的内容
     */
    public SpcySqsxBczgjl getNowZgtzContent(String sqsxid){
        List<SpcySqsxBczgjl> zgjlList = spcySqsxBczgjlService.list(new LambdaQueryWrapper<SpcySqsxBczgjl>()
                .eq(SpcySqsxBczgjl::getFsqsxid, sqsxid)
                .eq(SpcySqsxBczgjl::getFwczt, "否")
                .orderByDesc(SpcySqsxBczgjl::getFfqrq));
        if (CollectionUtil.isNotEmpty(zgjlList)){
            return zgjlList.get(0);
        }

        return null;
    }

    /**
     * 获取企业补充整改材料附件接口  (超创)  (10)
     * 跟超创再讨论一下
     */

    /***********************************************[     企业撤件 接口  ]*******************************************************/

    /**
     * 企业提出撤件申请以后，如果事项已经在审评中心现场检查现场检查环节，
     * 政务服务系统会调用审评系统的接受撤件申请接口，审评系统向经办人发送短信告知企业申请撤件，
     * 生成待办任务给经办人，经办人填写好意见以后系统调用政务服务系统的推送审评中心撤件意见接口完成推送。
     * 政务窗口办理撤件以后，向审评中心经办人发送短信告知办理结果。审评系统对事项流程进行终止，终止的类型是“企业撤件”。
     */

    /**
     * 接受撤件申请信息接口  (中心) (3)
     * 器械、药品生产、药品注册：政务服务向审评中心告知企业要撤件，请审评中心出具意见。
     * 流通、化妆品：不用给政务出具意见
     */
    public void jscjsqxx(XzspJkApiJscjsqParamVo jscjsqVo){

        /*String access_token = jscjsqVo.getAccess_token();
        if (StringUtils.isBlank(access_token)){
            throw new BusinessException("access_token不能为空！");
        }*/
        XzspJkApiJscjsqVo param = jscjsqVo.getParam();

        if (StringUtils.isBlank(param.getSxsqjbxx_id())){
            throw new BusinessException("操作失败，事项申请基本信息参数为空！");
        }
        if (StringUtils.isBlank(param.getCjsj())){
            throw new BusinessException("操作失败，撤件时间为空！");
        }

        /** 事项信息 */
        List<SpcySqsxBasic> sqsxList = spcySqsxBaiscService.list(new LambdaQueryWrapper<SpcySqsxBasic>()
                .eq(SpcySqsxBasic::getFsxsqjbxxid, param.getSxsqjbxx_id()));
        if (CollectionUtils.isEmpty(sqsxList)){
            throw new BusinessException("操作失败，没有相匹配的申请事项数据！");
        }

        SpcySqsxBasic sqsx = sqsxList.get(0);

        /** 修改事项状态 */
        spcySqsxBaiscService.updateSqsxByJscjsqxx(sqsx.getId(), param.getCjyy(), param.getCjsj());

        /** 经办人发送短信 */
        String zbrHzKsfzr = busService.getZbrHzKsfzr(sqsx);
        StringBuffer smsContent = new StringBuffer("【撤件通知】\n");
        smsContent.append(Optional.ofNullable(sqsx.getFqymc()).orElseGet(() -> "")).append(" ");
        smsContent.append(Optional.ofNullable(sqsx.getFsxmc()).orElseGet(() -> ""));
        smsContent.append(" 申请撤件。");

        if (StringUtils.isNotBlank(param.getCjyy())) {
            smsContent.append("\n撤件原因：").append(param.getCjyy()).append("，");
        }
        if (StringUtils.isNotBlank(param.getCjsj())){
            smsContent.append("\n撤件时间: ").append(param.getCjsj()).append("。");
        }
        busService.sendSmsToNodeDbr(zbrHzKsfzr, null, smsContent.toString());

        /** 同步撤件申请材料 */
        try {
            if (verifyEnableSyncZwfwxtQycjsqClFile()){
                sqsxQywjclService.syncZwxtCjsqclToLocalWjcl(sqsx.getId(), param.getSxsqjbxx_id());
            }
        }catch (Exception e){
            log.error("同步撤件申请材料错误：", e.getMessage());
        }

    }

    /**
     * 推送审评中心撤件意见接口 (超创) (4)
     * 用于审评中心向政务服务出具对企业申请撤件的意见
     * @param sqsxid 申请事项id
     * @param spzxyj 审评中心意见
     */
    public boolean pushSpzxCjyj(String sqsxid,String spzxyj){
        if (StringUtils.isBlank(sqsxid)){
            throw new BusinessException("申请事项参数为空！");
        }

        if (StringUtils.isBlank(spzxyj)){
            throw new BusinessException("意见为空！");
        }

        SpcySqsxBasic sqsx = spcySqsxBaiscService.selectSqsxInfoById(sqsxid);
        if (sqsx == null){
            throw new BusinessException("当前申请事项不存在！");
        }

        if (StringUtils.isBlank(sqsx.getFxzspzt()) || !sqsx.getFxzspzt().equals(SpcyConstant.SQSX_BASIC_XZSPZT_YES)){
            log.error("当前申请事项[{}]不属于政务服务系统数据，提交失败！", sqsx.getFsxmc());

            return true;
        }

        String sxsqjbxxid = sqsx.getFsxsqjbxxid();
        String tjsj = DateConversionUtils.DateToDays(new Date());

        CurrentUserVo currentUser = GetCurrentUserUtils.getCurrentUser();
        String loginName = currentUser.getLoginName();

        spcySqsxBaiscService.updateSqsxPushSpzxCjyj(sqsxid, spzxyj, tjsj);

        boolean isEnableSync = verifyEnableSyncSqsx(); // 是否开启同步
        boolean flag = false;
        if (isEnableSync) {
            // 推送撤件意见
            flag = xzspJkApi.pushSpzxCjyj(sxsqjbxxid, spzxyj, tjsj, loginName, null);
        }else {
            flag = true;
        }

        if (flag){
            spcySqsxBaiscService.updateSqsxPushSpzxCjyj(sqsxid);
        }

        return flag;
    }

    /**
     *  接受撤件结果信息接口  (中心) (5)
     *  用于审评中心接受政务服务执行撤件的结果
     */
    public void jscjjgxx(XzspJkApiJscjjgParamVo jscjjgVo){
        /*String access_token = jscjjgVo.getAccess_token();
        if (StringUtils.isBlank(access_token)) {
            throw new BusinessException("access_token不能为空！");
        }*/

        XzspJkApiJscjjgVo param = jscjjgVo.getParam();
        if (StringUtils.isBlank(param.getSxsqjbxx_id())){
            throw new BusinessException("操作失败，事项申请基本信息参数为空！");
        }
        if (StringUtils.isBlank(param.getCjjg())){
            throw new BusinessException("操作失败，撤件结果为空！");
        }
        if (StringUtils.isBlank(param.getFssj())){
            throw new BusinessException("操作失败，发送时间为空！");
        }

        /** 事项信息 */
        List<SpcySqsxBasic> sqsxList = spcySqsxBaiscService.list(new LambdaQueryWrapper<SpcySqsxBasic>()
                .eq(SpcySqsxBasic::getFsxsqjbxxid, param.getSxsqjbxx_id()));
        if (CollectionUtils.isEmpty(sqsxList)){
            throw new BusinessException("操作失败，没有相匹配的申请事项数据！");
        }

        /** 修改事项状态 */
        SpcySqsxBasic sqsx = sqsxList.get(0);
        spcySqsxBaiscService.updateSqsxByJscjjg(sqsx.getId(), param.getCjjg(), param.getFssj());

        /** 主办人发送短信 */
        String zbrHzKsfzr = busService.getZbrHzKsfzr(sqsx);
        StringBuffer smsContent = new StringBuffer("【撤件通知】\n");
        smsContent.append(Optional.ofNullable(sqsx.getFqymc()).orElseGet(() -> "")).append(" ");
        smsContent.append(Optional.ofNullable(sqsx.getFsxmc()).orElseGet(() -> ""));
        smsContent.append("申请的撤件完成了。");

        if (StringUtils.isNotBlank(param.getCjjg())) {
            smsContent.append("撤件结果：").append(param.getCjjg()).append("，");
        }
        if (StringUtils.isNotBlank(param.getFssj())){
            smsContent.append("提交时间: ").append(param.getFssj()).append("。");
        }
        busService.sendSmsToNodeDbr(zbrHzKsfzr, null, smsContent.toString());

    }

    /***********************************************[     政务系统-业务部门退回 接口  ]*******************************************************/

    /**
     *  已移送的数据如果有问题，政务服务系统调用审评系统的接受退回已移送数据接口，
     *  审评系统按各科室要求将事项退回到指定环节，并向对应办理人发送短信。
     */

    /**
     * 接受业务部门退回接口  (中心) (11)
     * 药品生产、流通、化妆：退给经办人
     * 器械：退给到科长复核环节
     */
    public void zwfwxtYwbmReturnJob(XzspJkApiJsywbmthParamVo jsywbmthVo){
        // 政务服务系统 - 退回功能
        spcyFlowService.zwfwxtReturnJob(jsywbmthVo);
    }

    /**
     * 获取未完成整改的事项信息
     */
    public List<SpcySqsxBczgjl> getNoZgwcSqsxList(){
        List<SpcySqsxBczgjl> zgList = spcySqsxBczgjlService.list(new LambdaQueryWrapper<SpcySqsxBczgjl>()
                .eq(SpcySqsxBczgjl::getFwczt, "否")
                .orderByAsc(SpcySqsxBczgjl::getFfqrq));

        return zgList;
    }

    /**
     * 获取未完成补齐不做的事项信息
     */
    public List<SpcySqsxBqbzjl> getNoBqbzwcSqsxList(){
        List<SpcySqsxBqbzjl> bqbzList = spcySqsxBqbzjlService.list(new LambdaQueryWrapper<SpcySqsxBqbzjl>()
                .eq(SpcySqsxBqbzjl::getFwczt, "否")
                .orderByAsc(SpcySqsxBqbzjl::getFfqrq));

        return bqbzList;
    }

    /**
     * 给主办人或者科室负责人-发送短信
     * @param sqsxid
     * @param sms
     */
    public void sendSmsToZbrHzKzfzr(SpcySqsxBasic sqsx,String sqsxid,String sms){
        if (sqsx == null) {
            if (StringUtils.isNotBlank(sqsxid)) {
                sqsx = spcySqsxBaiscService.getById(sqsxid);
            }
        }

        if (sqsx != null) {

            String baseSms = "";
            if (StringUtils.isNotBlank(sqsx.getFqymc())){
                baseSms += sqsx.getFqymc() + " 申请的 ";
            }


            if (StringUtils.isNotBlank(sqsx.getFsxmc())){
                baseSms += sqsx.getFsxmc() + ",";
            }

            if (StringUtils.isNotBlank(sqsx.getFsqdbh())){
                baseSms += "申请单号为["+sqsx.getFsqdbh()+"]。";
            }


            baseSms += sms;

            String dbrid = busService.getZbrHzKsfzr(sqsx);
            busService.sendSmsToNodeDbr(dbrid,null,baseSms);
        }

    }

    /**
     * 验证是否发起补齐补正(true: 已补正/false: 未补正)
     */
    public boolean verifySffqBqbz(String sqsxid){
        if (org.apache.commons.lang3.StringUtils.isBlank(sqsxid)){
            throw new BusinessException("参数为空！");
        }

        List<SpcySqsxBqbzjl> list = spcySqsxBqbzjlService.list(new LambdaQueryWrapper<SpcySqsxBqbzjl>()
                .eq(SpcySqsxBqbzjl::getFsqsxid, sqsxid));
        if (CollectionUtil.isNotEmpty(list)){
            return true;
        }else {
            return false;
        }
    }
}
